package com.ruoyi.learn.java.collection;

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Queue;

public class ArrayDequeDemo {
    public static void main(String[] args) {
        System.out.println("=== ArrayDeque 全功能演示 ===\n");

        // 🌟 场景 1：作为栈使用（LIFO - 后进先出）
        demoAsStack();

        // 🌟 场景 2：作为队列使用（FIFO - 先进先出）
        demoAsQueue();

        // 🌟 场景 3：作为双端队列（两端都可操作）
        demoAsDeque();

        // 🌟 场景 4：遍历操作
        demoTraversal();
    }

    // ✅ 场景 1：作为栈（Stack） - LIFO
    static void demoAsStack() {
        System.out.println("1. ArrayDeque 作为栈（Stack）使用");
        ArrayDeque<String> stack = new ArrayDeque<>();

        stack.push("First");
        stack.push("Second");
        stack.push("Third");

        System.out.println("栈顶元素: " + stack.peek()); // Third

        System.out.println("出栈顺序:");
        while (!stack.isEmpty()) {
            System.out.println("  " + stack.pop()); // Third → Second → First
        }
        System.out.println();
    }

    // ✅ 场景 2：作为队列（Queue） - FIFO
    static void demoAsQueue() {
        System.out.println("2. ArrayDeque 作为队列（Queue）使用");
        Queue<String> queue = new ArrayDeque<>(); // 也可以用 Deque

        queue.offer("First");
        queue.offer("Second");
        queue.offer("Third");

        System.out.println("队首元素: " + queue.peek()); // First

        System.out.println("出队顺序:");
        while (!queue.isEmpty()) {
            System.out.println("  " + queue.poll()); // First → Second → Third
        }
        System.out.println();
    }

    // ✅ 场景 3：作为双端队列（Deque） - 两端操作
    static void demoAsDeque() {
        System.out.println("3. ArrayDeque 作为双端队列（Deque）使用");
        ArrayDeque<String> deque = new ArrayDeque<>();

        // 从队首添加
        deque.addFirst("Front-1");
        deque.addFirst("Front-2"); // 更靠前

        // 从队尾添加
        deque.addLast("Back-1");
        deque.addLast("Back-2");

        System.out.println("当前双端队列: " + deque);
        // 输出: [Front-2, Front-1, Back-1, Back-2]

        // 从队首取出
        System.out.println("队首出队: " + deque.pollFirst()); // Front-2
        System.out.println("队尾出队: " + deque.pollLast());  // Back-2

        System.out.println("操作后: " + deque);
        // 输出: [Front-1, Back-1]
        System.out.println();
    }

    // ✅ 场景 4：遍历方式
    static void demoTraversal() {
        System.out.println("4. ArrayDeque 遍历方式");
        ArrayDeque<String> deque = new ArrayDeque<>();
        deque.add("Apple");
        deque.add("Banana");
        deque.add("Cherry");

        // 方式 1：增强 for 循环（从头到尾）
        System.out.println("遍历方式 1 - 增强 for:");
        for (String fruit : deque) {
            System.out.println("  " + fruit);
        }

        // 方式 2：迭代器（正向）
        System.out.println("遍历方式 2 - 迭代器:");
        deque.iterator().forEachRemaining(System.out::println);

        // 方式 3：反向遍历（从尾到头）
        System.out.println("遍历方式 3 - 反向遍历:");
        for (String fruit : deque) {
            // 不支持直接反向 for-each
        }
        // 正确方式：使用 descendingIterator()
        System.out.println("  反向:");
        deque.descendingIterator().forEachRemaining(System.out::println);
    }
}
